"""
1、在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

2、标准数据类型：
Python3 中常见的数据类型有：
    Number（数字）
    String（字符串）
    bool（布尔类型）
    List（列表）
    Tuple（元组）
    Set（集合）
    Dictionary（字典）

3、Python3 的六个标准数据类型中：
    不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
    可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
此外还有一些高级的数据类型，如: 字节数组类型(bytes)。

注意：
Python中的变量没有类型，我们常说的字符串变量，并不是说变量是字符串类型，而是：变量存储的数据是字符串类型
"""
print("==========变量============")
# 给多个变量赋值（创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值）
a = b = c = 1
print(f"a={a}")
print(f"b={b}")
print(f"c={c}")

# 多个对象指定多个变量（两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "cat" 分配给变量 c）
d, e, f = 1, 2, "cat"
print(d)
print(e)
print(f)

print("==========Number（数字）============")
a, b, c, d = 1, 2.5, '哈哈', True

print(a, b, c, d)
print(type(a), type(b), type(c), type(d))

# print(issubclass(bool, int))  # 判断bool类型是否为int的子类型。注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断类型。
# print(1 is True)  # 说明，1和True不是同一个类型
# print(True is 1)

print("==========数值运算============")
print(1 + 2)
print(6 - 1)
print(2 * 3)
print(6 / 4)  # 除法取小数，得到浮点数
print(6 // 4)  # 除法取整
print(6 % 4)  # 取余数
print(2 ** 3)  # 取平方值

print("==========字符串类型============")
s = "hello"
print(s)
print("字符串的截取的语法:变量[头下标:尾下标]")
print(s[0])
print(s[0:])
print(s[0:-1])
print(s[:-1])
print(s[-1])
print(s[:])
print(s * 3)  # *号表示复制
print('123\n456')
print(r'123\n456')  # r 标识符用于避免反斜杠（\）在字符串中的转义作用。
word = "python"
print(word[0], word[1])  # Python 没有单独的字符类型，一个字符就是长度为1的字符串
print(word[-1])

print("==========List列表============")
# 有序，元素可以被修改，写在中括号里，下标从0开始
list1 = [1, 2, 3, 4, 5, 6, 7]
print(list1)
print(list1[0])
print(list1[-1])
print(list1[1:3])  # 前闭后开
print(list1[3:])  # 前闭后闭(取第三个及以后的所有) 
print(list1[:3])  # 前闭后开(取第三个前的所有)
print(list1 * 2)  # 列表复制
list2 = ['a', 'b']
print(list1 + list2)
list3 = [1, 2, 3, 4]
list3[0] = 9  # 按照下标进行元素修改(替换)
print(list3)
list3[1:3] = [8, 7]  # 将下标1开始，下标3之前的元素，替换为8,7
print(list3)
list4 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list4[1:8])
print(list4[1:8:2])  # 列表截取元素时也可以添加步长参数，获取1~8之间的元素，步长为2

print("==========Tuple元组============")
# 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开，下标从0开始。
tuple1 = (1, 'a', 3.2, 'b', 5, 6)
tuple2 = (7, 8, 9)
print(tuple1)
print(tuple1[2])
print(tuple1[2:])  # 前闭后闭，取出第3个元素后的所有元素，包含第3个
print(tuple1[:2])  # 前边后闭，取出第2个元素前的所有元素，包含第2个
print(tuple1 * 2)  # 元组复制
print(tuple1 + tuple2)  # 元组整合
# t3 = (1, 2)
# t3[0] = 5  # 此处报错，元组中的元素不能被修改，TypeError: 'tuple' object does not support item assignment


print("==========Set集合============")
"""
无序，值可以被修改，元素不可重复
两种声明方式，{}或set()
"""
set1 = {'baidu', 'jd', 'ali', 'jd'}
print(set1)  # 输出去重后的集合
# 集合成员测试
if 'jd' in set1:
    print('存在')
else:
    print('不存在')

# 集合运算
a = set('1234')
b = set('3456')
print(a - b)  # 差集
print(a | b)  # 并集
print(a & b)  # 交集
print(a ^ b)  # 不同时存在的元素，两者各自没有的元素

print("==========Dictionary字典============")
"""
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用花括号 { } 标识，它是一个无序的【键(key) : 值(value)】的集合。
键(key)必须使用不可变类型。【不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；】
在同一个字典中，键(key)必须是唯一的。
"""
d1 = {}
d1['one'] = "1我是第一个"
d1[2] = '2小明'
print(d1)
print(d1[2])

d2 = {'name': '张三', 'age': '18'}
print(d2['age'])  # 通过key获取value
print(d2.keys())  # 获取所有的key
print(d2.values())  # 获取所有的value

print("==========bool布尔============")
result = 10 > 5
print(f"10 > 5 的结果是：{result}，类型是：{type(result)}")

ret = "abc" == "abcdef"
print(f"abc和abcdef字符串是否相等，结果是：{ret}，类型是：{type(ret)}")
